home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 December / PCWorld_2005-12_cd.bin / software / temacd / tiny / tpf-6[1].5.126.exe / Tiny Firewall 2005.msi / webui.dll / FIREWALL / FWN-SDBFNCS2.JS < prev    next >
Encoding:
Text (UTF-16)  |  2005-08-17  |  41.5 KB  |  803 lines
  1. /*//////////////////////////////////////////////////////////////////////
  2. Filename:          fwn-sdbfncs.js
  3. Company Name:      Computer Associates International, Inc.
  4. Legal Copyright: Copyright (c) Computer Associates International, Inc.
  5. Author:          Marek Matus (marek.matus@ca.com)
  6. Product:          Tiny Firewall
  7. Description:      javascript code to access active FW db through XMLSecDBParser COM iface
  8. ///////////////////////////////////////////////////////////////////////*/
  9.  
  10. // requires sdb-consts.js + sdb-msgs.js + tools.js + fwn-sdbfncs2.js
  11.  
  12. function FW_getRule( strRuleID, bIsRoutedRule, bUseClientParser)
  13. {
  14.     try {
  15.         var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  16.         return ruleList.Get(strRuleID);
  17.     } 
  18.     catch(e)
  19.     {
  20.         return null;
  21.     }    
  22. }
  23.  
  24. function FW_getDefinitionPROTO( strDefID, bUseClientParser)
  25. {
  26.     var definitionList = getDefinitionList( bUseClientParser );
  27.  
  28.     try
  29.     {
  30.         var oDef = definitionList.Get( strDefID );
  31.         
  32.         var itemEnum = new Enumerator(oDef.ItemList);
  33.         itemEnum.moveFirst();
  34.         return itemEnum.item();
  35.     }
  36.     catch (e)
  37.     {
  38.         return null;
  39.     }
  40. }
  41.  
  42. function FW_getDefinition( strDefID, bUseClientParser)
  43. {
  44.     var definitionList = getDefinitionList( bUseClientParser );
  45.  
  46.     try
  47.     {
  48.         return definitionList.Get( strDefID );
  49.     }
  50.     catch (e)
  51.     {
  52.         return null;
  53.     }
  54. }
  55.  
  56. function FW_isDefinitionEmpty( strDefID, bUseClientParser)
  57. {
  58.     var definitionList = getDefinitionList( bUseClientParser );
  59.  
  60.     try
  61.     {
  62.         var oDef = definitionList.Get( strDefID );
  63.         
  64.         var itemEnum = new Enumerator(oDef.ItemList);
  65.         itemEnum.moveFirst();
  66.         
  67.         if ( itemEnum.item() )
  68.             return false;
  69.     }
  70.     catch (e)
  71.     {
  72.     }
  73.     
  74.     return true;
  75. }
  76.  
  77. ///////////////////////////////////////////////////////////////////////
  78. // FS_SwitchRulePriority
  79. function FW_SwitchRulePriority( strRuleID, bIsRoutedRule )
  80. {
  81.     try {
  82.         
  83.         var ruleList = FW_getRuleList( false, bIsRoutedRule );
  84.         
  85.         var rule = ruleList.Get(strRuleID);
  86.         if (rule)
  87.             rule.Priority = (rule.Priority == PRIOR_LOW) ? PRIOR_HIGH : PRIOR_LOW;
  88.             
  89.         SaveParser(false);
  90.         
  91.         return SUCCESS;
  92.     } catch(e){
  93.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  94.     }
  95. }
  96.  
  97. function FW_easyRulesEnabled()
  98. {
  99.     var eList = new Enumerator( FW_getRuleList( false, false ) )
  100.     eList.moveFirst();
  101.  
  102.     while (!eList.atEnd())
  103.     {
  104.         var rule = eList.item();
  105.         
  106.         if ( FW_isEasyRule(rule.Priority==PRIOR_HIGH, rule.Preferred) )
  107.         {
  108.             //alert( rule.Enabled )
  109.             return rule.Enabled;
  110.         }
  111.             
  112.         eList.moveNext();
  113.     }
  114.     return true;
  115. }
  116.  
  117. function FW_isEasyRuleByID( strRuleID, bIsRoutedRule, bUseClientParser )
  118. {
  119.     var rule = FW_getRule( strRuleID, bIsRoutedRule, bUseClientParser);
  120.     
  121.     if ( rule )
  122.     {
  123.         return FW_isEasyRule(rule.Priority == PRIOR_HIGH, rule.Preferred);
  124.     }
  125.     
  126.     return false;
  127. }
  128.  
  129. function FW_isEasyRule(bHighPriority, bPreferred)
  130. {
  131.     return !bHighPriority && !bPreferred;
  132. }
  133.  
  134. ///////////////////////////////////////////////////////////////////////
  135. // FS_SwitchEasyRule
  136. function FW_SwitchEasyRule( strRuleID, bIsRoutedRule )
  137. {
  138.     try {
  139.         
  140.         var ruleList = FW_getRuleList( false, bIsRoutedRule );
  141.         
  142.         var rule = ruleList.Get(strRuleID);
  143.         if (rule)
  144.         {
  145.             var bEasy = FW_isEasyRule(rule.Priority == PRIOR_HIGH, rule.Preferred);
  146.             
  147.             if ( !bEasy )
  148.             {
  149.                 rule.Enabled = FW_easyRulesEnabled();
  150.                 rule.Preferred = false;
  151.             }
  152.             
  153.             rule.Priority = (bEasy? PRIOR_HIGH : PRIOR_LOW);
  154.         }
  155.  
  156.         SaveParser(false);
  157.         
  158.         return SUCCESS;
  159.     } catch(e){
  160.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  161.     }
  162. }
  163.  
  164. ///////////////////////////////////////////////////////////////////////
  165. // FW_SetPriority
  166. function FW_SetPriority( strRuleID, bHighPriority, bUseClientParser, bIsRoutedRule, bAvoidSavingSDB )
  167. {
  168.     try {
  169.  
  170.         var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  171.         var rule = ruleList.Get(strRuleID);
  172.         
  173.         if (rule)
  174.         {
  175.             if ( !parseBoolean( bUseClientParser ))
  176.                 rule.Priority = ( parseBoolean(bHighPriority) == 1) ? PRIOR_HIGH : PRIOR_LOW;
  177.         }
  178.  
  179.         if ( !parseBoolean(bAvoidSavingSDB) )
  180.             SaveParser(bUseClientParser);
  181.         //external.Save();
  182.         
  183.         return SUCCESS;
  184.     } catch(e){
  185.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  186.     }
  187. }
  188.  
  189. ///////////////////////////////////////////////////////////////////////
  190. // FW_SetPreferred
  191. function FW_SetPreferred( strRuleID, bPreferred, bUseClientParser, bIsRoutedRule, bAvoidSavingSDB )
  192. {
  193.     try {
  194.  
  195.         var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  196.         var rule = ruleList.Get(strRuleID);
  197.         
  198.         if (rule)
  199.         {
  200.             rule.Preferred = ( parseBoolean(bPreferred) == 1 ) ? true : false;
  201.         }
  202.  
  203.         if ( !parseBoolean(bAvoidSavingSDB) )
  204.             SaveParser(bUseClientParser);
  205.         //external.Save();
  206.         
  207.         return SUCCESS;
  208.     } catch(e){
  209.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  210.     }
  211. }
  212.  
  213. ///////////////////////////////////////////////////////////////////////
  214. // FW_SetDirection
  215. function FW_SetDirection( strRuleID, eDirection, bUseClientParser, bIsRoutedRule, bAvoidSavingSDB )
  216. {
  217.     try {
  218.  
  219.         var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  220.         var rule = ruleList.Get(strRuleID);
  221.         
  222.         if (rule)
  223.         {
  224.             if ( rule.TransportType == RT_DIRECT )
  225.             {
  226.                 rule.TransportObject.Direction = eDirection ? parseInt(eDirection) : 0;
  227.             }
  228.             else //RT_DEFINITION
  229.             {
  230.                 var definition;
  231.                 var defList = getDefinitionList( bUseClientParser );
  232.                 
  233.                 try
  234.                 {
  235.                     definition = defList.Get( rule.TransportID );
  236.                 }
  237.                 catch (e)
  238.                 {
  239.                     if ( !definition && bUseClientParser ) // it can be object from common database
  240.                     {
  241.                         defList = getDefinitionList( false );
  242.                         definition = defList.Get( rule.TransportID );
  243.                     }
  244.                 }
  245.                 
  246.                 var itemEnum = new Enumerator(definition.ItemList);
  247.                 itemEnum.moveFirst();
  248.                 var item = itemEnum.item();
  249.  
  250.                 item.Direction = eDirection ? parseInt(eDirection) : 0;
  251.             }
  252.         }
  253.  
  254.         if ( !parseBoolean(bAvoidSavingSDB) )
  255.             SaveParser(bUseClientParser);
  256.         //external.Save();
  257.         
  258.         return SUCCESS;
  259.     } catch(e){
  260.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  261.     }
  262. }
  263.  
  264. ///////////////////////////////////////////////////////////////////////
  265. // FW_SetLocPort
  266. function FW_SetLocPort( strRuleID, strLocalPorts, bUseClientParser, bIsRoutedRule, bAvoidSavingSDB )
  267. {
  268.     try {
  269.  
  270.         var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  271.         var rule = ruleList.Get(strRuleID);
  272.  
  273.         if (rule)
  274.         {
  275.             var item;
  276.  
  277.             if ( rule.TransportType == RT_DIRECT )
  278.             {
  279.                 item = rule.TransportObject;
  280.             }
  281.             else //RT_DEFINITION
  282.             {
  283.                 var definition;
  284.                 var defList = getDefinitionList( bUseClientParser );
  285.                 
  286.                 try
  287.                 {
  288.                     definition = defList.Get( rule.TransportID );
  289.                 }
  290.                 catch (e)
  291.                 {
  292.                     if ( !definition && bUseClientParser ) // it can be object from common database
  293.                     {
  294.                         defList = getDefinitionList( false );
  295.                         definition = defList.Get( rule.TransportID );
  296.                     }
  297.                 }
  298.                 
  299.                 var itemEnum = new Enumerator(definition.ItemList);
  300.                 itemEnum.moveFirst();
  301.                 item = itemEnum.item();
  302.             }
  303.  
  304.             item.LocalPortFrom = 0;
  305.             item.LocalPortTo = 0;
  306.             
  307.             if ( strLocalPorts )
  308.             {
  309.                 if ( strLocalPorts == "*")
  310.                     item.LocalPortTo = 65535;
  311.                 else
  312.                 {
  313.                     item.LocalPortFrom = parseInt(strLocalPorts);
  314.                     var Idx = strLocalPorts.search( "-" );
  315.                     if ((-1) != Idx)
  316.                         item.LocalPortTo = parseInt( strLocalPorts.substr(Idx+1) );
  317.                     else
  318.                         item.LocalPortTo = item.LocalPortFrom;
  319.                 }
  320.             }
  321.         }
  322.         //external.Save();
  323.         if ( !parseBoolean(bAvoidSavingSDB) )
  324.             SaveParser(bUseClientParser);
  325.  
  326.         return SUCCESS;
  327.     } catch(e){
  328.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  329.     }
  330. }
  331.  
  332. ///////////////////////////////////////////////////////////////////////
  333. // FW_SetRemPort
  334. function FW_SetRemPort( strRuleID, strRemotePorts, bUseClientParser, bIsRoutedRule, bAvoidSavingSDB )
  335. {
  336.     try {
  337.         var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  338.         var rule = ruleList.Get(strRuleID);
  339.  
  340.         if (rule)
  341.         {
  342.             var item;
  343.             
  344.             if ( rule.TransportType == RT_DIRECT )
  345.             {
  346.                 item = rule.TransportObject;
  347.             }
  348.             else //RT_DEFINITION
  349.             {
  350.                 var definition;
  351.                 var defList = getDefinitionList( bUseClientParser );
  352.                 
  353.                 try
  354.                 {
  355.                     definition = defList.Get( rule.TransportID );
  356.                 }
  357.                 catch (e)
  358.                 {
  359.                     if ( !definition && bUseClientParser ) // it can be object from common database
  360.                     {
  361.                         defList = getDefinitionList( false );
  362.                         definition = defList.Get( rule.TransportID );
  363.                     }
  364.                 }
  365.                 
  366.                 var itemEnum = new Enumerator(definition.ItemList);
  367.                 itemEnum.moveFirst();
  368.                 item = itemEnum.item();
  369.             }
  370.             item.RemotePortFrom = 0;
  371.             item.RemotePortTo = 0;
  372.  
  373.             if ( strRemotePorts )
  374.             {
  375.                 if ( strRemotePorts == "*")
  376.                     item.RemotePortTo = 65535;
  377.                 else
  378.                 {
  379.                     item.RemotePortFrom = parseInt(strRemotePorts);
  380.                     var Idx = strRemotePorts.search( "-" );
  381.                     if ((-1) != Idx)
  382.                         item.RemotePortTo = parseInt( strRemotePorts.substr(Idx+1) );
  383.                     else
  384.                         item.RemotePortTo = item.RemotePortFrom;
  385.                 }
  386.             }
  387.         }
  388.         
  389.         if ( !parseBoolean(bAvoidSavingSDB) )
  390.             SaveParser(bUseClientParser);
  391.  
  392.         return SUCCESS;
  393.     } catch(e){
  394.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  395.     }
  396. }
  397.  
  398.  
  399. ///////////////////////////////////////////////////////////////////////
  400. // FW_SetProtocol
  401. function FW_SetProtocol( strRuleID, eProtocol, strCustomProtocolNum, eICMPType, bUseClientParser, bIsRoutedRule, bAvoidSavingSDB )
  402. {
  403.     try {
  404.           var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  405.         var rule = ruleList.Get(strRuleID);
  406.         
  407.         if (rule)
  408.         {
  409.             var objTransport;
  410.             
  411.             if ( rule.TransportType == RT_DIRECT )
  412.                 objTransport = rule.TransportObject;
  413.             else  //RT_DEFINITION
  414.             {
  415.                 var definition;
  416.                 var defList = getDefinitionList( bUseClientParser );
  417.                 
  418.                 try
  419.                 {
  420.                     definition = defList.Get( rule.TransportID );
  421.                 }
  422.                 catch (e)
  423.                 {
  424.                     if ( !definition && bUseClientParser ) // it can be object from common database
  425.                     {
  426.                         defList = getDefinitionList( false );
  427.                         definition = defList.Get( rule.TransportID );
  428.                     }
  429.                 }
  430.                 
  431.                 var itemEnum = new Enumerator(definition.ItemList);
  432.                 itemEnum.moveFirst();
  433.                 objTransport = itemEnum.item();
  434.             }
  435.  
  436.             objTransport.Protocol = eProtocol ? parseInt(eProtocol) : 0;
  437.  
  438.             if (PROT_OTHER == objTransport.Protocol)
  439.             {
  440.                 var iProt = 0;
  441.                 var iProtFrom = 0;
  442.                 var iProtTo = 0;
  443.  
  444.                 if ( strCustomProtocolNum.search("-") > -1 )
  445.                 {
  446.                     var index = strCustomProtocolNum.search("-");
  447.  
  448.                     var strProtFrom = strCustomProtocolNum.substring(0,index);
  449.                     var strProtTo = strCustomProtocolNum.substring(index + 1);
  450.  
  451.                     iProtFrom = parseInt(strProtFrom);
  452.                     iProtTo = parseInt(strProtTo);
  453.                 }
  454.                 else
  455.                 {
  456.                     iProtFrom = parseInt(strCustomProtocolNum);
  457.                     iProtTo = parseInt(strCustomProtocolNum);
  458.                 }
  459.  
  460.                 iProt = (iProtTo * 65536) + iProtFrom;
  461.                 
  462.                 objTransport.CustomProtocolNumber = iProt;//isNaN(parseInt(iCustomProtocolNum)) ? 0 : parseInt(iCustomProtocolNum);
  463.             }
  464.             else if (PROT_ICMP == objTransport.Protocol )
  465.                 objTransport.ICMPType = isNaN(parseInt(eICMPType)) ? 0 : parseInt(eICMPType);
  466.         }
  467.         
  468.         if ( !parseBoolean(bAvoidSavingSDB) )
  469.             SaveParser(bUseClientParser);
  470.         
  471.         return SUCCESS;
  472.     } catch(e){
  473.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  474.     }
  475. }
  476.  
  477. ///////////////////////////////////////////////////////////////////////
  478. // FW_SetAuditLevel
  479. function FW_SetAuditLevel( strRuleID, eAuditLevel, bUseClientParser, bIsRoutedRule, bAvoidSavingSDB )
  480. {
  481.     try {
  482.           var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  483.         var rule = ruleList.Get(strRuleID);
  484.         
  485.         if (rule)
  486.             rule.AccessDescriptor.AccessResult = eAuditLevel ? parseInt(eAuditLevel) : 0;
  487.  
  488.         if ( !parseBoolean(bAvoidSavingSDB) )
  489.             SaveParser(bUseClientParser);
  490.             
  491.         return SUCCESS;
  492.     } catch(e){
  493.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  494.     }
  495. }
  496.  
  497. ///////////////////////////////////////////////////////////////////////
  498. // FW_SetAuditLevel
  499. function FW_SetZone( strRuleID, eZoneMask, bUseClientParser, bIsRoutedRule, bAvoidSavingSDB )
  500. {
  501.     try {
  502.           var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  503.         var rule = ruleList.Get(strRuleID);
  504.  
  505.         if (rule)
  506.             rule.Zone = (eZoneMask ? parseInt(eZoneMask) : 0) ? parseInt(eZoneMask) : (ZI_BIT_SAFE | ZI_BIT_DANGEROUS); // ZI_ALL_ZONES goes to exception here
  507.  
  508.         if ( !parseBoolean(bAvoidSavingSDB) )
  509.             SaveParser(bUseClientParser);
  510.             
  511.         return SUCCESS;
  512.     } catch(e){
  513.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  514.     }
  515. }
  516.  
  517. ///////////////////////////////////////////////////////////////////////
  518. // FW_SetDescription
  519. function FW_SetDescription( strRuleID, strDesc, bUseClientParser, bIsRoutedRule, bAvoidSavingSDB )
  520. {
  521.     try {
  522.           var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  523.         var rule = ruleList.Get(strRuleID);
  524.  
  525.         if (rule)
  526.             rule.Description = strDesc;
  527.  
  528.         if ( !parseBoolean(bAvoidSavingSDB) )
  529.             SaveParser(bUseClientParser);
  530.             
  531.         return SUCCESS;
  532.     } catch(e){
  533.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  534.     }
  535. }
  536.  
  537. ///////////////////////////////////////////////////////////////////////
  538. // FW_SetAccessResult
  539. function FW_SetAccessResult( strRuleID, eAccessResult, bUseClientParser, bIsRoutedRule, bAvoidSavingSDB )
  540. {
  541.     try {
  542.  
  543.           var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  544.         var rule = ruleList.Get(strRuleID);
  545.  
  546.         if (rule)
  547.             rule.AccessDescriptor.AuditLevel = eAccessResult ? parseInt(eAccessResult) : 0;
  548.  
  549.         if ( !parseBoolean(bAvoidSavingSDB) )
  550.             SaveParser(bUseClientParser);
  551.             
  552.         return SUCCESS;
  553.     } catch(e){
  554.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  555.     }
  556. }
  557.  
  558. ///////////////////////////////////////////////////////////////////////
  559. // FW_SetAccount
  560. function FW_SetAccount( strRuleID, eAccount, bUseClientParser, bIsRoutedRule, bAvoidSavingSDB)
  561. {
  562.     try {
  563.  
  564.           var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  565.         var rule = ruleList.Get(strRuleID);
  566.  
  567.         if (rule)
  568.             rule.Account = eAccount;
  569.  
  570.         if ( !parseBoolean(bAvoidSavingSDB) )
  571.             SaveParser(bUseClientParser);
  572.             
  573.         return SUCCESS;
  574.     } catch(e){
  575.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  576.     }
  577. }
  578.  
  579. ///////////////////////////////////////////////////////////////////////
  580. // FW_SetTransport
  581. function FW_SetTransport( strRuleID, strTransportID, bUseClientParser, bIsRoutedRule, bAvoidSavingSDB )
  582. {
  583.     try {
  584.  
  585.           var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  586.         var rule = ruleList.Get(strRuleID);
  587.  
  588.         if (rule)
  589.         {
  590.             if ( strTransportID )
  591.             {
  592.                 rule.TransportType = RT_DEFINITION;
  593.                 rule.TransportID = strTransportID;
  594.             }
  595.             else
  596.             {
  597.                 rule.TransportType = RT_DIRECT;
  598.                 FW_SetTransportObjectImpl( rule.TransportObject, PROT_ALL, 0, DIR_OUT, ICMP_ALL, "*", "*" );
  599.             }
  600.         }
  601.  
  602.         if ( !parseBoolean(bAvoidSavingSDB) )
  603.             SaveParser(bUseClientParser);
  604.  
  605.         return SUCCESS;
  606.     } catch(e){
  607.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  608.     }
  609. }
  610.  
  611. ///////////////////////////////////////////////////////////////////////
  612. // FW_SetRemoteAddress
  613. // If address object is specified and does not exist then it is created! It is important
  614. // for ldap users because are loaded from ldap server and have no ipaddress object in database.
  615. function FW_SetRemoteAddress( strRuleID, strRemIpAddrID, strRemIpAddr, bUseClientParser, bIsRoutedRule, bAvoidSavingSDB )
  616. {
  617.     try {
  618.         var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  619.         var rule = ruleList.Get(strRuleID);
  620.  
  621.         if (rule)
  622.         {
  623.             rule.RemIPAddrType = strRemIpAddrID ? RT_DEFINITION : RT_DIRECT;
  624.             rule.RemIPAddress = strRemIpAddrID ? strRemIpAddrID : (strRemIpAddr ? strRemIpAddr : "*");
  625.  
  626.             // if object does not exist then create it
  627.             if ( strRemIpAddrID && isLDAPSupported() && isLDAPName(strRemIpAddrID) && !parseBoolean(bUseClientParser))
  628.             {
  629.                 var definitionList = getDefinitionList(bUseClientParser);
  630.  
  631.                 try
  632.                 {
  633.                     var definition = definitionList.Get( strRemIpAddrID );
  634.                 }
  635.                 catch (e)
  636.                 {
  637.                     definition = definitionList.CreateDefinition();
  638.  
  639.                     definition.DefinitionID = strRemIpAddrID;
  640.                     definition.ObjectType = OT_FW_IPADDR;
  641.  
  642.                     definitionList.Insert( definition );
  643.                 }
  644.             }
  645.         }
  646.  
  647.         if ( !parseBoolean(bAvoidSavingSDB) )
  648.             SaveParser(bUseClientParser);
  649.         
  650.         return SUCCESS;
  651.     } catch(e){
  652.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  653.     }
  654. }
  655.  
  656. ///////////////////////////////////////////////////////////////////////
  657. // FW_SetLANAddress
  658. function FW_SetLANAddress( strRuleID, strLANIpAddrID, strLANIpAddr, bUseClientParser, bIsRoutedRule, bAvoidSavingSDB )
  659. {
  660.     try {
  661.     
  662.         var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  663.         var rule = ruleList.Get(strRuleID);
  664.  
  665.         if (rule)
  666.         {
  667.             if ( parseBoolean(bIsRoutedRule) != 0 )
  668.             {
  669.                 rule.LANIPAddrType = strLANIpAddrID ? RT_DEFINITION : RT_DIRECT;
  670.                 rule.LANIPAddress = strLANIpAddrID ? strLANIpAddrID : (strLANIpAddr ? strLANIpAddr : "*");
  671.             }
  672.             else
  673.             {
  674.                 rule.LocIPAddrType = strLANIpAddrID ? RT_DEFINITION : RT_DIRECT;
  675.                 rule.LocIPAddress = strLANIpAddrID ? strLANIpAddrID : (strLANIpAddr ? strLANIpAddr : "*");
  676.             }
  677.             
  678.             // if object does not exist then create it
  679.             if ( strLANIpAddrID && isLDAPSupported() && isLDAPName(strLANIpAddrID) && !parseBoolean(bUseClientParser))
  680.             {
  681.                 var definitionList = getDefinitionList(bUseClientParser);
  682.  
  683.                 try
  684.                 {
  685.                     var definition = definitionList.Get( strLANIpAddrID );
  686.                 }
  687.                 catch (e)
  688.                 {
  689.                     definition = definitionList.CreateDefinition();
  690.  
  691.                     definition.DefinitionID = strLANIpAddrID;
  692.                     definition.ObjectType = OT_FW_IPADDR;
  693.  
  694.                     definitionList.Insert( definition );
  695.                 }
  696.             }
  697.         }
  698.  
  699.         if ( !parseBoolean(bAvoidSavingSDB) )
  700.             SaveParser(bUseClientParser);
  701.  
  702.         return SUCCESS;
  703.     } catch(e){
  704.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  705.     }
  706. }
  707.  
  708.  
  709. ///////////////////////////////////////////////////////////////////////
  710. // FW_SetIFCAddress (only for routed rules).
  711. function FW_SetIFCAddress( strRuleID, strIFCIpAddrID, strIFCIpAddr, bUseClientParser, bIsRoutedRule, bAvoidSavingSDB )
  712. {
  713.     try {
  714.  
  715.           var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  716.         var rule = ruleList.Get(strRuleID);
  717.  
  718.         if (rule)
  719.         {
  720.             rule.IfaceIPAddrType = strIFCIpAddrID ? RT_DEFINITION : RT_DIRECT;
  721.             rule.IfaceIPAddress = strIFCIpAddrID ? strIFCIpAddrID : (strIFCIpAddr ? strIFCIpAddr : "*");
  722.         }
  723.  
  724.         if ( !parseBoolean(bAvoidSavingSDB) )
  725.             SaveParser(bUseClientParser);
  726.  
  727.         return SUCCESS;
  728.     } catch(e){
  729.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  730.     }
  731. }
  732.  
  733. ///////////////////////////////////////////////////////////////////////
  734. // FW_SetTime
  735. function FW_SetTime( strRuleID, strDayTimeID, strDayTime, bUseClientParser, bIsRoutedRule, bAvoidSavingSDB )
  736. {
  737.     try {
  738.           var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  739.         var rule = ruleList.Get(strRuleID);
  740.  
  741.         if (rule)
  742.         {
  743.             // don't really know the TimeOfDay format....
  744.             rule.TimeOfDayType = strDayTimeID ? RT_DEFINITION : RT_DIRECT;
  745.             rule.TimeOfDay = strDayTimeID ? strDayTimeID : (strDayTime ? strDayTime : "");
  746.         }
  747.  
  748.         if ( !parseBoolean(bAvoidSavingSDB) )
  749.             SaveParser(bUseClientParser);
  750.  
  751.         return SUCCESS;
  752.     } catch(e){
  753.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  754.     }
  755. }
  756.  
  757. ///////////////////////////////////////////////////////////////////////
  758. // FW_SetApp
  759. function FW_SetApp( strRuleID, strAppGroupID, strAppLabel, bUseClientParser, bIsRoutedRule, bAvoidSavingSDB )
  760. {
  761.     try {
  762.  
  763.           var ruleList = FW_getRuleList( bUseClientParser, bIsRoutedRule );
  764.         var rule = ruleList.Get(strRuleID);
  765.  
  766.         if (rule)
  767.         {
  768.             rule.Application = strAppGroupID ? strAppGroupID : strAppLabel;
  769.             rule.AppType = strAppGroupID ? AT_DEFINITION : AT_LABEL;
  770.         }
  771.  
  772.         if ( !parseBoolean(bAvoidSavingSDB) )
  773.             SaveParser(bUseClientParser);
  774.  
  775.         return SUCCESS;
  776.     } catch(e){
  777.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  778.     }
  779. }
  780.  
  781. ///////////////////////////////////////////////////////////////////////
  782. // FW_SetUsers
  783. function FW_SetUsers( strRuleID, strUsers, bAvoidSavingSDB )
  784. {
  785.     try {
  786.  
  787.           var ruleList = FW_getRuleList( false, false );
  788.         var rule = ruleList.Get(strRuleID);
  789.  
  790.         if (rule)
  791.         {
  792.             rule.Assignment = strUsers ? strUsers : "*";
  793.         }
  794.  
  795.         if ( !parseBoolean(bAvoidSavingSDB) )
  796.             SaveParser(false);
  797.  
  798.         return SUCCESS;
  799.     } catch(e){
  800.         return ErrorHandler( ERR_EDIT_FW_RULE_FAILED, STR_EDIT_FW_RULE_FAILED );
  801.     }
  802. }
  803.